package com.company;

class Link{  //链表类，外部能够看见的只有这一个类
    private class Node{     //定义的内部节点类
        private Object data;        //要保存数据
        private Node next;          //下一个节点引用
        public Node(Object data){   //每一个Node类对象都必须保存相应的数据
            this.data=data;
        }



        //保存节点
        public void addNode(Node newNode){
            if(this.next==null){
                this.next=newNode;
            }else{
                this.next.addNode(newNode);
            }
        }

        //数据检索，判定数据是否存在
        public boolean containsNode(Object data){
            if (data.equals(this.data)){
                return true;
            }else {
                if (this.next!=null){
                    return this.next.containsNode(data);
                }else {
                    return false;
                }
            }
        }
        //返回查询节点的数据索引
        public Object getNode(int index){
            if (Link.this.foot++==index){
                return this.data;
            }else{
                return this.next.getNode(index);
            }
        }

        //对索引的内容进行修改
        public void setNode(int index,Object data){
            if (Link.this.foot++==index){
                this.data=data;
            }else{
                this.next.setNode(index,data);
            }
        }

        //节点的删除操作
        public void removeNode(Node previous,Object data){
            if (data.equals(this.data)){
                previous.next=this.next;
            }else {
                this.next.removeNode(this,data);
            }
        }
        //将保存的内容转化为对象数组
        public void toArrayNode(){
            Link.this.retArray[Link.this.foot++]=this.data;
            if (this.next!=null){
                this.next.toArrayNode();
            }
        }
    }
    private Node root;      //根节点定义
    private int count=0;    //保存元素的个数
    private int foot=0;     //节点索引
    private Object [] retArray;   //返回的数组
    //要保存的数据
    public void add(Object data){
        if (data==null){
            return;
        }
        Node newNode=new Node(data);
        if (this.root==null){
            this.root=newNode;
        }else {
            this.root.addNode(newNode);
        }
        this.count++;       //数据保存成功后保存个数加一
    }
    public int size(){      //取得保存的数据量
        return this.count;
    }
    public boolean isEmpty(){
        return this.count==0;
    }
    //判断数据是否存在
    public boolean contains(Object data){
        if (data==null||this.root==null){
            return false;
        }
        return this.root.containsNode(data);
    }
    //索引数据
    public Object get(int index){
        if (index>this.count){
            return null;
        }
        this.foot=0;
        return this.root.getNode(index);
    }
    //索引修改数据
    public void set(int index,Object data){
        if (index>this.count){
            return;
        }
        this.foot=0;
        this.root.setNode(index,data);
    }
    //链表数据的删除操作，在删除前要先使用contains()判断链表中是否存在指定数据
    //其次判断删除数据是否为根节点
    //要删除数据如果是根节点，则将删除操作交由Node类的removeNode()方法完成。
    public void remove(Object data){
        if (this.contains(data)){
            if (data.equals(this.root.data)){
                this.root=this.root.next;
            }else {
                this.root.next.removeNode(this.root,data);
            }
            this.count--;
        }
    }
    //将链表中的数据转换为对象数组输出
    public Object[] toArray(){
        if (this.root==null){
            return null;
        }
        this.foot=0;
        this.retArray=new Object[this.count];
        this.root.toArrayNode();
        return this.retArray;
    }
    //清空链表数据
    public void clear(){
        this.root=null;
        this.count=0;
    }
}
